package shg.book.util
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Loader;
	import flash.display.Sprite;
	import flash.errors.IOError;
	import flash.events.Event;
	import flash.events.FocusEvent;
	import flash.events.MouseEvent;
	import flash.filesystem.File;
	import flash.filesystem.FileMode;
	import flash.filesystem.FileStream;
	import flash.geom.Point;
	import flash.geom.Rectangle;
	import flash.net.FileFilter;
	import flash.net.URLRequest;
	import flash.text.TextColorType;
	import flash.text.engine.TabAlignment;
	import flash.utils.ByteArray;
	
	import flashx.textLayout.conversion.ConversionType;
	import flashx.textLayout.conversion.TextConverter;
	import flashx.textLayout.edit.EditManager;
	import flashx.textLayout.operations.CopyOperation;
	
	import mx.collections.ArrayCollection;
	import mx.controls.Alert;
	import mx.controls.HTML;
	import mx.core.UITextField;
	import mx.graphics.codec.JPEGEncoder;
	import mx.managers.PopUpManager;
	import mx.messaging.channels.StreamingAMFChannel;
	import mx.validators.Validator;
	
	import spark.components.RichEditableText;
	import spark.utils.TextFlowUtil;
	
	public class BitmapBytes
	{
		
		private var loader:Loader;
		private var byArr:ByteArray;
		public var  bitmap:Bitmap;
		private var readFile:FileStream;
		public var bookPath:String;
		private var fileFileter:FileFilter;
		//存储的插入新图片之前原来图片BitmapData book.txtcreationComplete
		public var oldArray:ByteArray;
		//存储的插入新图片之前原来存储的图片大小
		private var oldLength:uint;
		//存储的是每一张图片的大小，以字节为单位
		public var imgLength:ArrayCollection;
		//图片宽度设置
		public var img_height:String;
		//图片高度设置
		public var img_width:String;
		//页码
		public var page_number:Number=1;
		//textFlow标签
		static private var textFlow_label:XML;
		//当前页的图片存储在这个数组里面
		static public var current_img:ArrayCollection;
		//原来存储图片的大小和索引index
		static public var img_size_index:ArrayCollection;
		//存储每一页HTML大小
		private var html_size_index:ArrayCollection;
		
		private var  newxml:XML;
		//最近这种图片的索引&
		 public var index:Number;
		//textFlow标签
		public var textFlow_label:XML;
		//存储图片的序号
		private var img_sequence:ArrayCollection;
		//作者姓名
		private var _authorName:String;
		//作者密码
		private var _authorPassword:String;
		//附件数组
		private var affix_array:ByteArray;
		//这个字节数组存储的是所有文件内容
		private var book_bytes:ByteArray;
		
		static private var img_index:uint=0;
		//所有图片大小
		private var all_size:uint=0;
		public var bitmp:Bitmap;
		private var contentHTML:ArrayCollection;
		public var richEditableText:RichEditableText;
		private var md5:MD5;
		//从上面传下来的密钥信息，此信息已经经过MD5加密
		public var KDC:String="";
		private var file:File;
		private var stream:FileStream;
		public function BitmapBytes()
		{
		}
		/**
		 *这里是初始化文件里面的图片数组长度
		 * @img_index  这是初始化图片的索引
		 * @page_number  这是初始化页码book.txt
		 * */
		public function initDate():void{
			var init_str:String="";
			var file:File=new File(bookPath);
			if(file.exists){
				var system:FileStream=new FileStream();
				system.open(file,FileMode.READ);
				if(system.bytesAvailable>0){
					try{
						var byteArray:ByteArray=new ByteArray();
						system.readBytes(byteArray);
						var length:uint=byteArray.bytesAvailable;
						//把图片数组索引，图片ID索引，HTML的大小表示出来，他们之间有 & 隔开
						init_str = initAffix(length,byteArray);
						
						//这里的第一个是图片大小数组，第二个是图片索引数组，第三个是HTML大小数组，后面的30是固定数据长度
						var three_array:uint=Number(init_str.split("&")[0])+Number(init_str.split("&")[1])+Number(init_str.split("&")[2])+30;
						system.position=length-three_array;
						var img_str:String=system.readMultiByte(Number(init_str.split("&")[0]),"UTF-8");
						var img_array:Array=new Array();
						img_array=img_str.split("&");
						img_index=img_array.length;
						
						system.position=length-three_array+(Number(init_str.split("&")[0])+Number(init_str.split("&")[1]))
						var html_str:String=system.readMultiByte(Number(init_str.split("&")[2]),"UTF-8");
						var html_arrary:Array=new Array();
						html_arrary=html_str.split("_");
						//初始化页码，+1 就是当前页了
						//page_number=html_arrary.length+1;
					}catch(e:Error){
						trace("读取文件出现异常："+e.toString());
					}
				}
				system.close();
			}
			
		}
		/**
		 * 打开图像
		 *选择你所需要的图像
		 * */
		public function openImg():void{
			fileFileter=new FileFilter("选择文件图像*.jpg *.png *.gif","*.jpg;*.png;*.gif");
			var file:File=File.documentsDirectory;
			file.browseForOpen("打开图像",[fileFileter]);//默认为用户文档路径img
			file.addEventListener(Event.SELECT,loaderImg);
		}
		
		/**
		 * 根据图像路径加载图像
		 * */
		private function loaderImg(event:Event):void{
			loader = new Loader();//Loader 类可用于加载 SWF 文件或图像（JPG、PNG 或 GIF）文件
			var file:File=event.target as File;
			var filePath:String=file.nativePath.toString();//获取选择文件的路径
			var request:URLRequest = new URLRequest(filePath);
			loader.contentLoaderInfo.addEventListener(Event.COMPLETE,getBmpInfo);
			loader.load(request); //加载URLRequest指定的文件
		}
		/**
		 * 读取图像文件
		 * 
		 **/
		public  function readImg():Bitmap{
			var file:File = new File("C:\\book.shg");    //若没有此文件就创建它
			//读取文件二进制数据
			var bytes:ByteArray=new ByteArray();
			var b:ByteArray=new ByteArray();
			readFile=new FileStream();
			readFile.open(file,FileMode.READ);
			readFile.readBytes(bytes);//首先一次性的读取文件里面的所有数据
			bytes.position=0;//将光标移动到下一个将要读取的起点
			bytes.readBytes(b,0,9796);//
			bitmap =ByteArrayToBitmap(b);
			readFile.close();
			trace("宽度"+bitmap.width+"长度"+bitmap.height+"名称"+bitmap.name);
			return bitmap;
		} 
		/**
		 *因为我们把一张图形保存到某个文件的时候不能把数据保存到指定的位置
		 * 所以为了保存前面输入的数据我们必须在文件里面的数据先读取到数组里面
		 * 然后再把最近这次读取到的数据添加到数组的末尾。然后再把数组的数据保存
		 * 进文件以免丢失
		 * 下面这个方法是当我们准备插入一张图片的时候就立刻把刚才保存进文件的数据
		 * 读取到数组里面
		 * */
		private function getOldFromFile():void{
			var file:File = new File(bookPath);    //若没有此文件就创建它
			//读取文件二进制数据
			oldArray=new ByteArray();
			readFile=new FileStream();
			readFile.open(file,FileMode.READ);
			readFile.readBytes(oldArray,0);//保存所有的图形进来
			readFile.close();
		}
		/**
		 * 这里获取的是图片的大小和用户设置的宽度和高度
		 * 把它保存到一个临时文件夹里面@id
		 * */
		private function getNewImgSize(newImgSize:ByteArray):void{
			var length:uint=newImgSize.length;
			if(length>0){
				var img_length:String=String(length);
				var file:File=new File(File.applicationStorageDirectory.nativePath+"\\"+"fcy.txt");
				var readLength:FileStream=new FileStream();
				readLength.open(file,FileMode.APPEND);
				//如果有设置宽度,这一这里的顺序首先是宽度其次是高度
				if(img_width!=null&&img_width!=""){
					img_length+=":"+img_width
				}
				//如果设置高度
				if(img_height!=null&&img_height!=""){
					img_length+=":"+img_height
				}
				if(file.size>0){
					readLength.writeMultiByte("-"+img_length,"gb2312");
				}else{
					readLength.writeMultiByte(img_length,"gb2312");
				}
				readLength.close();
			}
		}
		/**
		 * 把图片存储在一个字节数组里面
		 * 
		 * */ 
		private function getBmpInfo(event:Event):void{
			bitmp = (Bitmap)(loader.content);
//			if(bitmp.height>=BookSize.PAGE_CONTENT_HEIGTH || bitmp.width >= BookSize.PAGE_CONTENT_WIDTH){
//				var createImgSize:CreateImgSize=CreateImgSize(PopUpManager.createPopUp(editBook,CreateImgSize,false));
//				var point1:Point=new Point(0,0);
//				point1=richEditableText.localToGlobal(point1);
//				createImgSize.x=point1.x-BookSize.BORDER_MARGIN;
//				createImgSize.y=point1.y-BookSize.BORDER_MARGIN;
//				createImgSize.img_Height=BookSize.PAGE_CONTENT_HEIGTH;
//				createImgSize.bitmapBytes=this;
//				createImgSize.sourceImg.source=bitmp;
//				return;
//			}
//			
			//把图片暂时保存进入数组里面
			saveImgToArray(bitmp);
		}
		
		public  function BitmapDataToByteArray(target:Bitmap):ByteArray{
			var imageWidth:uint = target.width;
			var imageHeigh:uint = target.height;
			//创建一个具有指定高度和宽度的BitmapData对象
			var srcBmp:BitmapData = new BitmapData(imageWidth,imageHeigh);
			srcBmp.draw(target);//或者指定路径的图片
			//从像素数据的矩形区域生成一个字节数组
			var pixels:ByteArray = srcBmp.getPixels(new Rectangle(0,0,imageWidth,imageHeigh));
			//如果图像的宽度比页面还要宽的话就设置其为页面的宽度，高度也是如此
			pixels.writeShort(imageHeigh);
			pixels.writeShort(imageWidth);
			return pixels;
		}
		
		public function ByteArrayToBitmap(byArr:ByteArray):Bitmap{
			if(byArr == null)
				return null;
			var bmd:ByteArray = byArr;
			bmd.position = bmd.length - 2;
			var imageWidth:int = bmd.readShort();
			bmd.position = bmd.length - 4;
			var imageHeight:int = bmd.readShort();
			var copyBmp:BitmapData = new BitmapData(imageWidth,imageHeight,true);
			bmd.position = 0;
			for(var i:uint=0;i<imageHeight;i++){
				for(var j:uint=0;j<imageWidth;j++){
					copyBmp.setPixel(j,i,bmd.readUnsignedInt());
				}
			}
			var bmp:Bitmap = new Bitmap(copyBmp);
			return bmp;
		}
		/**
		 * 这里把图片保存到暂时保存到数组里面
		 * 等待作者点击保存的才把数组里面的图id
		 * 片添加到文件里面
		 * */
		public function saveImgToArray(bitmap:Bitmap):void{
			byArr = bitmapTobyteArray(bitmap);
			if(current_img==null)
				current_img=new ArrayCollection();
			if(img_size_index==null)
				img_size_index=new ArrayCollection();
			byArr.position=0;
			current_img.addItem(byArr);
			//其实这里就是当前这张图片的索引位置，img_index表示项目初始化的已经计算出文件里面本来具有的图片有多少张（数组的索引是从0开始，而我们的索引是从1开始）
			index=current_img.length;
			var _index:String="";
			for(var i:int=(String(index).length-1);i>=0;i--){
				_index+=String(index).charAt(i);
			}
			//这个数组存储的是当前的图片大小和索引位置，如：3200-110
			var str:String=String(byArr.length)+"-"+String(index);
			img_size_index.addItem(str);
			//注意这里的设计 这主要为了给每一个img做一个唯一的标志，稍后为img设置@id将会用到
			var str_height:String="."+_index;
			var _str:Array=String(bitmap.height).split(".");//如果某张图片的存在小数就得去掉以免对我们的音响
			var _height:String=String(_str[0])+String(str_height);
			
			var str_width:String=".0"+String(page_number+1);
			var _str_width:Array=String(bitmap.width).split(".");//如果某张图片的存在小数就得去掉以免对我们的音响
			var _width:String=String(_str_width[0])+String(str_width);
			/**
			 * 注意上面的操作就会得到如下的结果
			 * 从图片的高度_height我们就可以知道如片的序号index。而这个就是我们对应的当前这种图片的索引
			 * 即current_img的index索引，而数组img_size_index里面也存储有这个索引而且还有当前图片的大小
			 * 这样如果我们要搜索某张图片就很简单了根据图片的_height就会算出他的索引img_size_index里面得到
			 * 从img_size_index也可以算出图片的存储其实位置和介绍位置
			 * */
			richEditableText.setFocus();//设置焦点，以免作者没有点击编辑控件直接添加图片显示不出来
			var em:EditManager = richEditableText.textFlow.interactionManager as EditManager;
			em.selectRange(richEditableText.selectionAnchorPosition, richEditableText.selectionActivePosition);
			em.insertInlineGraphic(bitmap,_width,_height);
			richEditableText.textFlow.flowComposer.updateAllControllers();
		}
		/**
		 * 把Bitmap类型的数据转换为ByteArray类型的数据
		 * */
		private function bitmapTobyteArray(bitmap:Bitmap):ByteArray{
			var imageWidth:uint = bitmap.width;
			var imageHeigh:uint = bitmap.height;
			//创建一个具有指定高度和宽度的BitmapData对象
			var srcBmp:BitmapData = new BitmapData(imageWidth,imageHeigh);
			//或者指定路径的图片
			srcBmp.draw(bitmap);
			var jpg:JPEGEncoder = new JPEGEncoder(50);
			var bytes:ByteArray = jpg.encode(srcBmp);
			return bytes;
		}
		//当作者是保存的话就需要清空编辑器并将数据保存到数组里面
		public   function savePage(xml:XML):void{
			//bookPath=AuthorEdit.filePath;
			//把返回XML转换为一个String字符串
			var str:String=xml.toXMLString();
			//总长度
			var length:Number=str.length;
			//下面的目的只有一个就是把 <TextFlow></TextFlow>标签删除，因为它带有命名空间，下面采用的E4X无法操作这个带命名空间的XML
			var first:Number=str.indexOf(">",0);
			var last:Number=str.lastIndexOf("<",length);
			var list:XMLList=new XMLList(str.slice(first+1,length-(length-last)));
			//把textFlow保存在一个临时变量
			textFlow_label=new XML(str.slice(0,first+1)+str.slice(last,length));
			newxml=new XML(<order></order>);
			newxml.appendChild(list);
			
			editImg_id(newxml.children());
		}
		/**
		 * 这一步就是真正的给所有的img标签设置ID并赋值
		 * */
		private function editImg_id(list:XMLList):void{
			var imgLength:Number=list.img.length();
			//先判断其是否存在子节点,如果存在子节点当前节点是否存在img
			if(list.length()>0){
				if(imgLength>0){
					for(var i:Number=0;i<imgLength;i++){
						var str_height:String=String(list.img[i].@height);
						var _height:Array=str_height.split(".");
						var _index:String="";
						for(var j:int=(String(_height[1]).length-1);j>=0;j--){
							_index+=String(_height[1]).charAt(j);
						}
						var str_width:String=String(list.img[i].@width);
						var _width:Array=str_width.split(".");
						list.img[i].@id=String(_width[1])+"_"+_index;
						if(img_sequence==null)
							img_sequence=new ArrayCollection();
						img_sequence.addItem(list.img[i].@id);
					}
				}
			}
			//如果还存在子节点就递归调用
			if(list.children().length()>0){
				editImg_id(list.children());
			}else{
				//当循环完一页的HTML最后就需要把这个HTML复位并以字节保存在一个数组里面，首先将字符串转为直接流
				var xml:XML = textFlow_label.appendChild(newxml.children());
				var xml_str:String=xml.toXMLString();
				//存储每一页字节数组的大小。它的索引和页码是一样的，页面从0开始计算
				if(html_size_index==null)
					html_size_index=new  ArrayCollection();
				html_size_index.addItem(xml_str.length);
				
				if(contentHTML==null)
					contentHTML=new ArrayCollection();
				//暂时保存进入数组里面时候把这个和图片数据一起保存进文件（比量保存）
				contentHTML.addItem(xml_str);
			}
		}
		
		/**
		 * 删除作者在编辑的时候可能已经删除的图片
		 * 如果已经删除某张图片那么我们就不需要到存储图片数组
		 * 信息里面取出对应的图片数据了
		 * */
		public function writeToFile():void{
			var j:int;
			var k:int;
			var _index:Number;
			var delete_str:String="";
			var _sequence:Number;
			var deleteImg_index:ArrayCollection;
			if(img_size_index!=null){
				for(j=0; j<img_size_index.length ; j++){
					_index=Number((String(img_size_index[j]).split("-"))[1]);
					delete_str=String(j)+"_"+String(_index);
					//如果作者在编辑的时候插入某张图片然后有删除这时候在img_sequence数组就不可能存在，但是在img_size_index存在
					if(img_sequence==null){
						if(deleteImg_index==null)
							deleteImg_index=new ArrayCollection();
						deleteImg_index.addItem(delete_str);//同时要把存储图片对应的索引位置保存在一个数组里面，稍后要把对应的索引位置的图片删除
					}else{
						//如果img_sequence已经创建但是里面还没有值
						if(img_sequence.length!=0){
							for(k=0 ; k<img_sequence.length ; k++){
								_sequence=Number((String(img_sequence[k]).split("_"))[1]);
								if(_sequence==_index)
									break;
								if(k==(img_sequence.length-1)){//如过找到最后都没有找到的话就清除数组里面的数据
									if(deleteImg_index==null)
										deleteImg_index=new ArrayCollection();
									deleteImg_index.addItem(delete_str);//同时要把存储图片对应的索引位置保存在一个数组里面，稍后要把对应的索引位置的图片删除
								}
							}
						}else{
							deleteImg_index.addItem(delete_str);
						}
					}
				}
				//这里把删除的图片从数组删除
				if(deleteImg_index != null){
					//这里是从后面开始删除，如果从前面删除的话就会影响后面的索引位置
					for(var m:int=(deleteImg_index.length-1);m>=0;m--){
						var n:Number=Number(String(deleteImg_index[m]).split("_")[0]);
						current_img.removeItemAt(n);
						//上面删除了在这里需要保存一个空的进去做个占位符
						var nullByte:ByteArray=new ByteArray();
						current_img.addItemAt(nullByte,n);
						var item:String="0-"+String(String(deleteImg_index[m]).split("_")[1]);
						img_size_index.removeItemAt(n);//首先把数组中原来存储图片大小的数据清除
						img_size_index.addItemAt(item,n);//把自己新构造的数据插入到刚才删除的位置，目的是起到占位符的作用
					}
				}
			}
			//加密和写入文件
			writeDateToFile();
		}
		/**
		 * 最就是保存数据进入文件的最后一步。需要如下的数据信息
		 * 一：首先准备MD5加密，准备MD5加密,从后面往前获取2000个字节，并对其进行加密，如果不到2000只需要Html和后面的数据加密即可
		 * 1.显示获取所有的HTML文本字节
		 * */
		private function writeDateToFile():void{
			var KDCLength:uint=0;//需要加密的长度
			var html_str:String="";
			var imgByte:ByteArray=new ByteArray();
			var htmlByte:ByteArray=new ByteArray();
			var bytes:ByteArray=new ByteArray();
			var _str:String="";
			var md5_KDC:String="";
			for(var L:uint=0;L<contentHTML.length;L++){
				html_str+=contentHTML[L];
			}
			//editBook.conver_size各个封面的大小
			//html_str+=editBook.conver_size+"&";
			html_str+=arrayTostr(img_size_index);
			html_str+=arrayTostr(img_sequence);
			html_str+=arrayTostr(html_size_index);
			for(var i:uint=0;i<5;i++){//这里是扩展字段以后可能会用到
				html_str+=setLength(0);
			}
			//editBook.conver_size各个封面的大小
			//html_str+=setLength((editBook.conver_size+"&"+arrayTostr(img_size_index)).length);
			html_str+=setLength(arrayTostr(img_sequence).length);
			html_str+=setLength(arrayTostr(html_size_index).length);
			if(html_str.length+setLength(1).length>2000){//如果大于2000就取出后面那2000来加密
				KDCLength=2000;
				html_str+=setLength(KDCLength);
			}else{//否则就取出全部htmlByte加密,注意后面这里的10表示需要加密的长度，0000000800
				KDCLength=html_str.length+10+setLength(1).length;
				html_str+=setLength(KDCLength);
			}
			html_str+=setLength(1);//0表示纯文本1表示HTML文本数据2表示漫画
			
			htmlByte.writeMultiByte(html_str,"UTF-8");
			htmlByte.position=htmlByte.length-KDCLength;
			if(md5==null)
				md5=new MD5();
			 _str=htmlByte.readMultiByte(KDCLength,"UTF-8");
			 if(KDC.length>0){
				 md5_KDC=changeBook(_str);
				 _str=_str.substring(0,KDCLength-(10*6))+"0000000064"+html_str.substring(KDCLength-(10*5),html_str.length);
			 }else{
				 md5_KDC=freeBook(_str);
				 _str= _str.substring(0,KDCLength-(10*6))+"0000000032"+html_str.substring(KDCLength-(10*5),html_str.length);
			 }
			 //这里特别注意
			 htmlByte.position=0;
			 htmlByte.readBytes(bytes,0,htmlByte.length-KDCLength);
			 bytes.writeMultiByte(_str,"UTF-8");
			 
			 for(var j:uint=0;j<current_img.length;j++){
				 imgByte.writeBytes(ByteArray(current_img.getItemAt(j)));
			 }
			 
			 //把该写入文件的数据按照顺序传给此方法
			// fileWrite(editBook.fourCoverPage,imgByte,md5_KDC,bytes);
			 //最后把该删除的数据删除
			 clear();
		}
		
		//这个方法是将数组转为字符串
		private function arrayTostr(array:ArrayCollection):String{
			var _index:String="";
			for(var i:uint=0;i<array.length;i++){
				if(i==(array.length-1)){
					_index+=array[i];
				}else{
					_index+=array[i]+"&";
				}
			}
			return _index;
		}
		/**
		 * 这是一本收费的数据，加密的时候需要把作者输入的密钥信息也
		 * 文本字符串一起加密
		 * 这本书籍的整体加密有三次
		 * */
		private function changeBook(_str:String):String{
			//第二次加密（KDC就是第一次加密）
			var KDC_two:String=md5.getMD5(_str);
			//第三次加密
			var KDC_three:String=md5.getMD5(_str+KDC_two);
			//第四加密
			var KDC_four:String=md5.getMD5(KDC_three+KDC);
			//返回加密信息
			return KDC_three+KDC_four;
		}
		/**
		 * 这是一本免费的书籍，加密的时候没有用户输入的密钥信息
		 * 这本书籍的加密只有2此
		 * */
		private function freeBook(_str:String):String{
			//第一次加密
			var KDC_one:String=md5.getMD5(_str);
			//第二次加密
			var KDC_two:String=md5.getMD5(_str+KDC_one);
			//返回加密信息
			return KDC_two;
		}
		/**
		 * 将传进来的数据信息写入文件
		 * 写入的顺序是安装参数的顺序写入的
		 * fourCoverPage表示封面的四张图片的大小
		 * imgByte正文里面的图片信息
		 * md5_KDC加密后的字符串
		 * htmlByte文本HTML内容
		 * */
		private function fileWrite(fourCoverPage:ByteArray,imgByte:ByteArray,md5_KDC:String,htmlByte:ByteArray):void{
			//最后把数据写入到文件里面
			if(file==null)
		    	file=new File(bookPath);
			if(stream==null)
				stream=new FileStream();
			try{
				stream.open(file,FileMode.WRITE);
				if(fourCoverPage!=null){
					fourCoverPage.position=0;
					stream.writeBytes(fourCoverPage);
				}
				if(imgByte!=null){
					imgByte.position=0;
					stream.writeBytes(imgByte);
				}
				if(md5_KDC.length>0)
					stream.writeMultiByte(md5_KDC,"UTF-8");
				if(htmlByte!=null){
					htmlByte.position=0;
					stream.writeBytes(htmlByte);
				}
				stream.close();
			}catch(error:IOError){
				trace("文件不存在；您没有足够的权限打开该文件；您正在打开文件以进行读取访问，但您没有读取权限；或您正在打开文件以进行写入访问，但您没有写入权限");
			}
		}
		/**
		 * 清除所有的编辑内容包括编辑器里面的内容
		 * 和数组里面存储的内容
		 * page_number加一表示下一页
		 * */
		private function clear():void{
			contentHTML.removeAll();
			img_sequence.removeAll();
			html_size_index.removeAll();
		}
		/**
		 * @str  这里读取到的是2308-1&2308-2&0-3这样的
		 *		 一个字节数组，表示的是当前存储在文件里面图片的
		 * 		大小 - 前面是每张图片大小 - 后面是图片的序号
		 * @addByte 从文件里面读取到的所有文件的信息
		 * @array 当前额的图片大小和索引 2308-1
		 * */
		private function write_img(_str:String,addByte:ByteArray,array:ArrayCollection):String{
			var offset:uint=0;
			if(_str!=null||_str!=""){
				_str=_str;
			}else{
				_str="";
			}
			//如果当前文件里面存储有图片
			if(_str.length>0){
				var str_array:Array=new Array();
				str_array=_str.split("&");
				for(var g:uint=0;g<str_array.length;g++){
					var size_inde:String=str_array[g];
					var get_size:Array=new Array();
					get_size=size_inde.split("-");
					var img_size:String=get_size[0];
					all_size+=Number(img_size);
				}
				if(book_bytes==null)
					book_bytes=new ByteArray();
				book_bytes.writeBytes(addByte,offset,all_size);
			}
			//再把当前页的图片也追加进去
			if(current_img!=null){
				for(var q:uint=0;q<current_img.length;q++){
					var v:ByteArray=new ByteArray();
					v=current_img[q];
					book_bytes.writeBytes(v);
				}
			}
			//这是把当前的img_size_index追加字节数组
			if(array!=null){
				for(var f:uint=0;f<array.length;f++){
					if(_str.length>0){
						_str+="&"+array[f];
					}else{
						if(f>0){
							_str+="&"+array[f];
						}else{
							_str=array[f];
						}
					}
				}
			}
			if(affix_array==null)
				affix_array=new ByteArray();
			
			affix_array.writeMultiByte(_str,"UTF-8");
			
			return setLength(_str.length);
		}
		/**
		 * 这里组装sequence数组，把从文件里面读取出来的
		 * 和当前也的序列数组相加连接在一起
		 *@_str 文件里面图片的ID数组，格式如下：2_01&3_02，说明 _ 表示的是页码， _ 表示的是图片的序号，全书唯一的序号
		 *@_squese  当前页的图片ID序列数组
		 * */
		private function make_sequence(_str:String,_squese:ArrayCollection):String{
			if(_str!=null||_str!=""){
				_str=_str;
			}else{
				_str="";
			}
			if(_str.length>0){
				if(_squese!=null){
					for(var y:uint=0;y<_squese.length;y++){
						_str+="&"+_squese[y];
					}
				}
			}else{
				if(_squese!=null){
					for(var x:uint=0;x<_squese.length;x++){
						if(x>0){
							_str+="&"+_squese[x];
						}else{
							_str+=_squese[x];
						}
					}
				}
			}
			if(affix_array==null)
				affix_array=new ByteArray();
			
			affix_array.writeMultiByte(_str,"UTF-8");
				
			return setLength(_str.length) ;
		}
		/**
		 * HTML的读写
		 * */
		private function write_html(_str:String,addByte:ByteArray,html_byte:ByteArray,html_size:ArrayCollection):String{
			if(_str!=null||_str!=""){
				_str=_str;
			}else{
				_str="";
			}
			
			addByte.position=all_size;
			book_bytes.position=book_bytes.position;
			
			//下面是组装HTML Size
			if(_str.length>0){
				var _strArray:Array=new Array();
				var _size:Number=0;
				_strArray=_str.split("_");
				for(var r:uint=0;r<_strArray.length;r++){
					_size+=Number(_strArray[r]);
				}
				book_bytes.writeBytes(addByte,addByte.position,_size);
				
				//把当前页的HTML长度和原来文件里面的长度累加起来	
				for(var p:uint=0;p<html_size.length;p++){
					_str+="_"+html_size[p];
				}
			}else{
				for(var k:uint=0;k<html_size.length;k++){
					if(k>0){
						_str+="_"+html_size[k];
					}else{
						_str+=html_size[k];
					}
				}
			}
			
			book_bytes.writeBytes(html_byte);
			
			if(affix_array==null)
				affix_array=new ByteArray();
			
			affix_array.writeMultiByte(_str,"UTF-8");
			
			return setLength(_str.length);
		}
		/**
		 * 
		 * 传进来一个字节数组，这个字节数组是从附件里面读取到的所有数据
		 * 根据这个字节数组分析里面的数据
		 * */
		private function initAffix(isread:uint,affixArray:ByteArray):String{
			var img_array_Length:uint=0;
			var img_sequence_Length:uint=0;
			var html_array_Length:uint=0;
			
			affixArray.position = isread-30;
			
			img_array_Length=Number(affixArray.readMultiByte(10,"UTF-8"));//获取到存储图片的大小和索引的数组
			
			img_sequence_Length=Number(affixArray.readMultiByte(10,"UTF-8"));//读取到存储图片序号的数组
			
			html_array_Length=Number(affixArray.readMultiByte(10,"UTF-8"));//存储HTML代码的字节数组
			
			return String(img_array_Length)+"&"+String(img_sequence_Length)+"&"+String(html_array_Length);
		}
		/**
		 * 传进来一个整数返回一个有0组成的字符串
		 * */
		private function setLength(_str:Number):String{
			var str_length:String=String(_str);
			var str:String="";
			if(str_length!=null){
				for(var r:int=0;r<10-String(_str).length;r++){
					str+="0";
				}
			}else{
				return "0000000000";
			}
			str_length=str+str_length;
			return str_length;
		}
		/**
		 * 传进来一个字节数组 返回一个字符串
		 * 
		 * */
		private function conneteArray(array:ArrayCollection):String{
			if(array!=null){
				var img_str:String="";
				for(var a:int=0;a<array.length;a++){
					if(a>0){//从第二个开始就需要用&符号分割数组
						img_str+="&"+array[a];
					}else{
						img_str+=array[a];
					}
					if(a==(array.length-1)){//如果到了最后一位
						var affix_img_index:ByteArray=new ByteArray();
						//这里的工作其实就是把String类型转换为byteArray类型
						affix_img_index.writeMultiByte(img_str,"UTF-8");
						//在把转换之后的数据类型存储在buyeArray数组里面从0开始
						if(book_bytes==null)
							book_bytes=new ByteArray();
						book_bytes.writeBytes(affix_img_index);
						//计算出图片字节数组的长度
						return String(affix_img_index.length);
					}
				}
			}
			return null;
		}
		/**
		 * 这里是获取作者的用户名，然后把此作者名称进行MD5加密返回的一个字符串
		 * 在以后的修改只有作者输入用户名和密码最后才能进行修改
		 * 这一个函数是在作者编辑完一本书的最后步发布书籍才执行
		 * 才把加密之后的字符串插入到图片的后面
		 * */
		private function name_password():String{
			var md5:MD5=new MD5(); 
			_authorName="冯成议";
			_authorPassword="123456";
			var md5_str:String=_authorName.toString()+_authorPassword.toString();
			return md5.getMD5(md5_str);
		}

	}
}